Course: Core Java Training
Topic: Installing and Configuring the Java Development Kit (JDK)
Course Link: Core Java Training Course
Demo Link: Register for a Course Demo
Website: JustAcademy Official Website
The Java Development Kit (JDK) is a software development package required to develop, compile, debug, and run Java applications. It provides the tools and libraries programmers need to create Java programs.
Before writing and executing Core Java programs, a developer should install a suitable JDK and configure the development environment correctly. Without a working Java compiler, Java source code cannot be compiled into bytecode.
The JDK is available for operating systems such as Windows, macOS, and Linux. The installation procedure varies depending on the operating system and the selected JDK distribution.
Before installing Java, it is useful to understand the differences between the JDK, JRE, and JVM.
| Component | Full Form | Purpose |
|---|---|---|
| JDK | Java Development Kit | Provides tools for developing, compiling, debugging, and running Java applications. |
| JRE | Java Runtime Environment | Traditionally refers to the runtime components and libraries needed to run Java applications. |
| JVM | Java Virtual Machine | Executes Java bytecode and provides the runtime environment for Java programs. |
Important: Modern JDK distributions may not provide a separate JRE installer. Installing a JDK is the standard approach when learning Java programming.
Check the following requirements before beginning the installation process.
Choose a JDK version that matches your course requirements, project requirements, and development tools. Long-Term Support (LTS) releases are often suitable for learning and long-running projects. Confirm compatibility before selecting a version.
Official download page: Oracle Java Downloads.
Other distributions are also available, including Eclipse Temurin and Microsoft Build of OpenJDK. Review the applicable licence and support terms before choosing a distribution for commercial use.
The first step is to download a JDK package that is compatible with your operating system and hardware.
Use official vendor websites to reduce the risk of downloading modified or unsafe installation files.
Windows users can generally install the JDK through a graphical installer or use a supported package-management method. The exact screens and installation paths depend on the distribution and version.
.exe extension or an MSI package.The JDK may be installed in a directory similar to the following:
C:\Program Files\Java\jdk-25This is an example path only. The actual directory depends on the installed JDK version and distribution. Locate the folder on your computer before configuring environment variables.
Open the JDK installation directory and look for a bin folder. It should contain development tools such as java.exe and javac.exe.
The java command launches the Java runtime, while javac compiles Java source files.
JAVA_HOME is an environment variable that points to the root directory of a JDK installation. Some development tools, build systems, and scripts use this variable to locate Java.
JAVA_HOME.C:\Program Files\Java\jdk-25.bin subfolder.Variable name: JAVA_HOME
Variable value: C:\Program Files\Java\jdk-25Replace the example path with the actual path on your system. Do not copy it blindly if your installed JDK uses a different directory.
The PATH environment variable tells the operating system where to search for executable commands. Adding the JDK's bin directory to PATH allows commands such as java and javac to be used from a terminal without entering their full paths.
Path variable under User variables or System variables.bin directory.%JAVA_HOME%\bin.%JAVA_HOME%\binBest practice: Add a separate PATH entry instead of replacing the existing PATH value. Replacing it may prevent other applications and operating-system tools from working correctly.
On macOS, the JDK is commonly installed using a vendor-provided package installer or another supported installation method.
.dmg or .pkg file.java -version to inspect the Java version selected by your system.javac -version to verify compiler availability.On many macOS installations, this command lists detected JDK installations:
/usr/libexec/java_home -VTo print the path of the JDK selected by the system, use:
/usr/libexec/java_homeFor a terminal session, you can set JAVA_HOME using the following command:
export JAVA_HOME=$(/usr/libexec/java_home)
export PATH="$JAVA_HOME/bin:$PATH"These commands affect the current shell session unless you add the configuration to the appropriate shell startup file. The exact configuration may differ according to the shell and JDK distribution.
Linux users can install a JDK through their distribution's package manager or by downloading an archive or package from a JDK vendor. Package names and commands vary by Linux distribution and repository.
Refresh package information:
sudo apt updateInstall a JDK package available in the configured repositories. For example, on a repository that provides OpenJDK 21:
sudo apt install openjdk-21-jdkIf that package is unavailable, check the versions supported by your distribution and repositories. Choose a package that matches your course or project requirements.
On Fedora systems with the relevant package available, a JDK can be installed with a command similar to:
sudo dnf install java-21-openjdk-develPackage names and available versions can differ between distributions and releases.
java -version
javac -versionFirst, identify the actual JDK installation directory. You can inspect the resolved location of the Java executable with:
readlink -f "$(command -v java)"The resulting path may point to a file inside the JDK's bin directory or to a system-managed alternative. Determine the correct JDK root directory before assigning JAVA_HOME.
For a temporary shell configuration, use the appropriate path:
export JAVA_HOME=/path/to/your/jdk
export PATH="$JAVA_HOME/bin:$PATH"Replace /path/to/your/jdk with the actual JDK root directory. For persistent configuration, add the correct commands to the relevant shell configuration file or use your operating system's supported environment configuration method.
After installing and configuring the JDK, verify that the operating system can locate both the Java runtime command and the Java compiler.
Open a new Command Prompt, PowerShell, Terminal, or Linux shell and run:
java -versionThe output should display the installed or selected Java runtime version. The exact output depends on the vendor and version.
javac -versionThis command should display the compiler version. If the command is not recognized, the JDK may not be installed correctly or its bin directory may not be available through PATH.
On Windows Command Prompt:
echo %JAVA_HOME%On Windows PowerShell:
$env:JAVA_HOMEOn macOS or Linux shells:
echo "$JAVA_HOME"The displayed value should point to the JDK root directory, not to a source file or the bin folder.
After confirming that the JDK works, create a simple Java program to test the complete development workflow.
Create a file named HelloJava.java and enter the following code:
public class HelloJava {
public static void main(String[] args) {
System.out.println("Java JDK is configured successfully!");
}
}Use Command Prompt, PowerShell, or a terminal and navigate to the folder containing HelloJava.java.
javac HelloJava.javaIf compilation succeeds, the compiler creates a file named HelloJava.class in the output directory.
java HelloJavaExpected output:
Java JDK is configured successfully!When running the program, use the class name without the .java or .class extension. This simple exercise confirms that source code can be compiled and executed using the JDK.
A JDK installation contains multiple directories and tools. Their exact arrangement may vary by version and distribution.
| Tool or Directory | Purpose |
|---|---|
bin |
Contains executable development and runtime tools. |
javac |
Compiles Java source code into bytecode. |
java |
Launches Java applications. |
jshell |
Provides an interactive environment for experimenting with Java expressions and statements in supported JDK versions. |
javadoc |
Generates API documentation from source comments. |
jar |
Creates and manages Java archive files. |
lib |
Contains libraries and supporting files used by the JDK. |
An Integrated Development Environment (IDE) makes it easier to write, compile, run, and debug Java applications. Examples include IntelliJ IDEA, Eclipse, and Visual Studio Code with appropriate Java extensions.
Important: Installing an IDE does not always install a separate system-wide JDK or configure PATH and JAVA_HOME for every application. Verify the IDE's selected runtime and the terminal configuration independently.
| Error or Symptom | Possible Cause | Solution |
|---|---|---|
java is not recognized on Windows |
The JDK's bin directory is missing from PATH, or the terminal has not refreshed its environment. | Check PATH, verify the installation directory, and open a new terminal. |
javac is not recognized |
The JDK is missing, or PATH points to the wrong location. | Confirm that the JDK contains javac and add the correct bin directory to PATH. |
| JAVA_HOME points to an invalid directory | The path contains a typo or points to the bin folder instead of the JDK root. | Set JAVA_HOME to the actual JDK root directory. |
| An unexpected Java version appears | Multiple JDK installations or system-managed alternatives may be present. | Inspect PATH order, JAVA_HOME, and the executable selected by the system. |
| Compilation fails with a version error | The source code or compiled class may require a different Java version. | Check the project's required Java version and the compiler selected by the terminal or IDE. |
| Permission denied during installation | The selected directory requires additional privileges. | Use an authorized installation location or obtain the required permissions. |
| The installer is incompatible | The package may not match the operating system or processor architecture. | Download the appropriate package from the vendor's official site. |
These commands help identify which Java executable is selected by the system.
where java
where javac
echo %JAVA_HOME%Get-Command java
Get-Command javac
$env:JAVA_HOMEwhich java
which javac
echo "$JAVA_HOME"On Unix-like systems, which shows the command found through PATH. On macOS, you can also use /usr/libexec/java_home -V to list detected JDK installations when the utility is available.
If multiple versions are installed, check the selected executable and update the configuration carefully. Avoid deleting existing Java installations until you know which applications depend on them.
Download and install a suitable JDK version for your operating system. Record the version number and installation directory.
Set JAVA_HOME to your JDK root directory and configure PATH to include the JDK's bin directory. Open a new terminal and verify the values.
Run java -version and javac -version. Write down the output and explain what each command verifies.
Create HelloJava.java, compile it with javac, and execute it with java. Confirm that the expected message appears.
Describe the steps you would take if java works but javac is not recognized. Include checks for the installation directory, PATH, and the selected JDK.
Create a small Java application that displays a welcome message and the current Java runtime version.
public class JavaSetupCheck {
public static void main(String[] args) {
System.out.println("Java environment check");
System.out.println("Java version: " +
System.getProperty("java.version"));
System.out.println("Operating system: " +
System.getProperty("os.name"));
}
}Save the file as JavaSetupCheck.java, then compile and run it:
javac JavaSetupCheck.java
java JavaSetupCheckThis project demonstrates that a Java application can retrieve runtime information through system properties. Remember that the program reports the runtime executing it; use javac -version separately to inspect the compiler version.
Answer: The Java Development Kit is a collection of development tools and libraries used to compile, debug, and run Java applications.
Answer: The JDK provides development tools and supporting components, while the JVM executes Java bytecode at runtime.
Answer: JAVA_HOME is an environment variable commonly used to identify the root directory of a JDK installation.
Answer: It allows commands such as java and javac to be found and executed from a terminal without specifying their full paths.
Answer: The Java compiler translates Java source files into class files containing Java bytecode.
Answer: Run javac -version and java -version. The compiler command is particularly useful for confirming that development tools are available.
Answer: The terminal, IDE, or build tool may select a different Java version from the one expected by the project. Check PATH, JAVA_HOME, and each tool's configured JDK.
Answer: No. Basic Java commands can work through PATH without JAVA_HOME, but many build tools and development environments use it to locate a JDK.
Answer: Yes. Java programs can be written in a text editor and compiled and executed from a terminal using the JDK tools.
Answer: Open a new terminal session and verify the commands again so that the updated environment variables are loaded.
java -version.javac -version.Installing and configuring the Java Development Kit is a foundational step in learning Core Java. A correct installation provides the compiler, runtime tools, and libraries needed to develop Java applications.
By selecting a compatible JDK, configuring JAVA_HOME and PATH when needed, checking the Java and compiler versions, and compiling a simple program, learners can establish a reliable Java development environment. These skills are useful when working with command-line tools, IDEs, and Java projects.
To explore structured Core Java learning resources, visit JustAcademy's Core Java Training Course, register for a course demo, or visit the JustAcademy official website.
